#pragma once
#include <cstring>

namespace StringVariants {

  /**
   * @brief 简化版的直接拷贝字符串（Eager Copy）。
   *
   *  - 每个实例独立拥有一段堆缓冲区。
   *  - 拷贝构造时总是完整复制底层数据，不做共享。
   *  - 仅用于演示或 Benchmark 场景，未实现完整的异常安全处理。
   */
  class EagerStringSimple {
  public:
    /**
     * @brief 默认构造函数，初始化为空字符串。
     */
    EagerStringSimple() : data_(nullptr), size_(0), capacity_(0) {}

    /**
     * @brief 通过 C 风格字符串初始化。
     *
     * @param s 指向以 '\0' 结尾的字符序列；若为 nullptr 则视为长度为 0。
     */
    explicit EagerStringSimple(const char *s) {
      if (!s) {
        data_ = nullptr;
        size_ = capacity_ = 0;
        return;
      }
      size_ = capacity_ = std::strlen(s);
      data_ = new char[capacity_ + 1];
      std::memcpy(data_, s, size_ + 1);
    }

    /**
     * @brief 拷贝构造函数，深拷贝另一对象的内容。
     */
    EagerStringSimple(const EagerStringSimple &other) {
      size_ = other.size_;
      capacity_ = other.capacity_;
      if (capacity_) {
        data_ = new char[capacity_ + 1];
        std::memcpy(data_, other.data_, size_ + 1);
      } else {
        data_ = nullptr;
      }
    }

    /**
     * @brief 析构函数，释放堆缓冲区。
     */
    ~EagerStringSimple() {
      delete[] data_;
    }

    /**
     * @brief 在字符串尾部追加单个字符。
     *
     * @param c 需要追加的字符。
     * @note 缓冲区容量不足时自动扩容，扩容策略为每次翻倍。
     */
    void push_back(char c) {
      if (size_ == capacity_) {
        reserve(capacity_ ? capacity_ * 2 : 8);
      }
      data_[size_++] = c;
      data_[size_] = '\0';
    }

    /**
     * @brief 获取 C 风格的字符串视图。
     *
     * @return 若内部为空返回 ""，否则返回有效指针。
     */
    const char *c_str() const { return data_ ? data_ : ""; }

    /**
     * @brief 当前字符串长度。
     */
    std::size_t size() const { return size_; }

  private:
    /**
     * @brief 调整底层缓冲区容量。
     *
     * @param new_cap 目标容量，若小于等于现有容量则不做处理。
     */
    void reserve(std::size_t new_cap) {
      if (new_cap <= capacity_) return;
      char *buf = new char[new_cap + 1];
      if (data_) {
        std::memcpy(buf, data_, size_ + 1);
        delete[] data_;
      } else {
        buf[0] = '\0';
      }
      data_ = buf;
      capacity_ = new_cap;
    }

    char *data_;              ///< 指向堆分配的字符数据。
    std::size_t size_;        ///< 当前有效字符数量（不含终止符）。
    std::size_t capacity_;    ///< 当前分配的缓冲区容量。
  };

} // namespace StringVariants